home *** CD-ROM | disk | FTP | other *** search
/ AMIGA-CD 2 / Amiga-CD - Volume 2.iso / ungepackte_daten / 1994 / 8 / 05 / term-4.0-source.lha / termMarker.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-06-17  |  16.4 KB  |  756 lines
  1. /*
  2. **    termMarker.c
  3. **
  4. **    Text block marker routines
  5. **
  6. **    Copyright © 1990-1994 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #include "termGlobal.h"
  11. #include "termEmulationProcess.h"
  12.  
  13.     /* BM_Draw():
  14.      *
  15.      *    Redraw or remove marked regions.
  16.      */
  17.  
  18. VOID __regargs
  19. BM_Draw(struct BlockMarker *Marker,VOID (*Select)(struct BlockMarker *Marker,LONG Left,LONG Top,LONG Width,LONG Height))
  20. {
  21.         /* Is the first line the same as the last line? If so,
  22.          * continue and mark only single characters. Else,
  23.          * determine first line and column to mark and last
  24.          * line and last column.
  25.          */
  26.  
  27.     if(Marker -> FirstLine != Marker -> LastLine)
  28.     {
  29.         LONG    First    = Marker -> FirstLine - Marker -> Top,
  30.             Last    = Marker -> LastLine  - Marker -> Top,
  31.             Lines;
  32.  
  33.             /* Is the first line visible? If so, mark it. */
  34.  
  35.         if(First >= 0)
  36.             (*Select)(Marker,Marker -> FirstColumn,First,Marker -> Width - Marker -> FirstColumn,1);
  37.         else
  38.         {
  39.             (*Select)(Marker,0,0,Marker -> Width,1);
  40.  
  41.             First = 0;
  42.         }
  43.  
  44.             /* Is the last line visible? If so, mark it. */
  45.  
  46.         if(Last >= 0 && Last < Marker -> Height)
  47.             (*Select)(Marker,0,Last,Marker -> LastColumn,1);
  48.         else
  49.             Last = Marker -> Height;
  50.  
  51.             /* Determine the number of lines the selection spans. */
  52.  
  53.         if((Lines = Last - First - 1) > 0)
  54.             (*Select)(Marker,0,First + 1,Marker -> Width,Lines);
  55.     }
  56.     else
  57.     {
  58.             /* Is the first column different from the last column? */
  59.  
  60.         if(Marker -> FirstColumn != Marker -> LastColumn)
  61.         {
  62.                 /* Is the line visible? If so, mark it. */
  63.  
  64.             if(Marker -> Top <= Marker -> LastLine && Marker -> LastLine < Marker -> Top + Marker -> Height)
  65.                 (*Select)(Marker,Marker -> FirstColumn,Marker -> FirstLine - Marker -> Top,Marker -> LastColumn - Marker -> FirstColumn,1);
  66.         }
  67.     }
  68. }
  69.  
  70.     /* BM_ClearMark(struct BlockMarker *Marker):
  71.      *
  72.      *    Free block marker memory.
  73.      */
  74.  
  75. VOID __regargs
  76. BM_ClearMark(struct BlockMarker *Marker)
  77. {
  78.     BM_Draw(Marker,Marker -> Unselect);
  79.  
  80.     FreeVecPooled(Marker);
  81. }
  82.  
  83.     /* BM_SetMark():
  84.      *
  85.      *    Create block marker structure.
  86.      */
  87.  
  88. struct BlockMarker * __regargs
  89. BM_SetMark(APTR Object,VPTR Select,VPTR Unselect,LONG Width,LONG Height,LONG LeftEdge,LONG TopEdge,LONG Top,LONG Lines,LONG X,LONG Y,WORD TextFontWidth,WORD TextFontHeight)
  90. {
  91.     if(Height && Lines)
  92.     {
  93.         struct BlockMarker *Marker;
  94.  
  95.             /* Allocate marker buffer. */
  96.  
  97.         if(Marker = (struct BlockMarker *)AllocVecPooled(sizeof(struct BlockMarker),MEMF_ANY | MEMF_CLEAR))
  98.         {
  99.                 /* Fill in the object or canvas, usually a RastPort. */
  100.  
  101.             Marker -> Object    = Object;
  102.  
  103.                 /* Fill in the canvas left and top edge. */
  104.  
  105.             Marker -> LeftEdge    = LeftEdge;
  106.             Marker -> TopEdge    = TopEdge;
  107.  
  108.                 /* Fill in the select and unselect routines. */
  109.  
  110.             Marker -> Select    = Select;
  111.             Marker -> Unselect    = Unselect;
  112.  
  113.                 /* Fill in current display window top and number of
  114.                  * lines in the buffer.
  115.                  */
  116.  
  117.             Marker -> Top        = Top;
  118.             Marker -> Lines        = Lines;
  119.  
  120.                 /* Fill in width and height of the display window. */
  121.  
  122.             Marker -> Width        = Width;
  123.             Marker -> Height    = Height;
  124.  
  125.                 /* Fill in the marker anchor point. */
  126.  
  127.             Marker -> FirstColumn    = X;
  128.             Marker -> LastColumn    = X;
  129.             Marker -> FirstLine    = Y + Top;
  130.             Marker -> LastLine    = Y + Top;
  131.  
  132.                 /* Fill in current mouse position. */
  133.  
  134.             Marker -> LastX        = X;
  135.             Marker -> LastY        = Y;
  136.  
  137.             Marker -> OriginX    = X;
  138.             Marker -> OriginY    = Y + Top;
  139.  
  140.                 /* Remember text font dimensions. */
  141.  
  142.             Marker -> TextFontWidth    = TextFontWidth;
  143.             Marker -> TextFontHeight= TextFontHeight;
  144.  
  145.             Marker -> WriteMask    = ((struct RastPort *)Object) -> Mask;
  146.         }
  147.  
  148.             /* Return marker buffer. */
  149.  
  150.         return(Marker);
  151.     }
  152.     else
  153.         return(NULL);
  154. }
  155.  
  156.     /* BM_ExtendMark(struct BlockMarker *Marker,LONG X,LONG Y,LONG Delta):
  157.      *
  158.      *    Extend current block marker. This routine was
  159.      *    first written by me, but Martin Berndt rewrote it
  160.      *    after we both realised that it would not work
  161.      *    properly.
  162.      */
  163.  
  164. VOID __regargs
  165. BM_ExtendMark(struct BlockMarker *Marker,LONG X,LONG Y,LONG Delta)
  166. {
  167.     if(Marker -> LastX != X || Marker -> LastY != Y)
  168.     {
  169.         LONG    OldCharPos,NewCharPos,
  170.             CharStart,CharEnd,
  171.             CharOrigin,
  172.             OriginY,
  173.             Lines;
  174.         BYTE    Crossed;
  175.  
  176.             OriginY = Marker -> OriginY - Marker -> Top;
  177.  
  178.  
  179.             /* Deal with illegal X position. */
  180.  
  181.         if(X < 0)
  182.             X = 0;
  183.  
  184.         if(X > Marker -> Width)
  185.             X = Marker -> Width;
  186.  
  187.             /* Deal with illegal Y position. */
  188.  
  189.         if(Y < 0)
  190.             Y = 0;
  191.  
  192.         if(Y >= Marker -> Height)
  193.             Y = Marker -> Height - 1;
  194.  
  195.         if(Y + Marker -> Top >= Marker -> Lines)
  196.             Y = Marker -> Lines - Marker -> Top - 1;
  197.  
  198.             /* Is the Y position larger than the last line? If so,
  199.              * truncate it.
  200.              */
  201.  
  202.         if(Y > Marker -> Lines - Marker -> Top)
  203.             Y -= Marker -> Lines - Marker -> Top;
  204.  
  205.             /* Select the text. */
  206.  
  207.         OldCharPos    = (Marker -> LastY + Marker -> Top) * Marker -> Width + Marker -> LastX;
  208.         NewCharPos    = (Y + Marker -> Top) * Marker -> Width + X;
  209.  
  210.         CharStart    = Marker -> FirstLine * Marker -> Width + Marker -> FirstColumn;
  211.         CharEnd        = Marker -> LastLine * Marker -> Width + Marker -> LastColumn;
  212.  
  213.         CharOrigin    = Marker -> OriginY * Marker -> Width + Marker -> OriginX;
  214.  
  215.         Crossed        = (OldCharPos < CharOrigin) ^ (NewCharPos < CharOrigin);
  216.  
  217.         if(NewCharPos > OldCharPos)
  218.         {
  219.             if(Delta && Y < OriginY)
  220.                 (*Marker -> Select)(Marker,0,Y,Marker -> Width,1);
  221.  
  222.             if(Crossed)
  223.             {
  224.                 if((Lines = OriginY - Marker -> LastY - 1) >= 0)
  225.                 {
  226.                     (*Marker -> Unselect)(Marker,Marker -> LastX,Marker -> LastY,Marker -> Width - Marker -> LastX,1);
  227.  
  228.                     if(Lines > 0)
  229.                         (*Marker -> Unselect)(Marker,0,Marker -> LastY + 1,Marker -> Width,Lines);
  230.  
  231.                     if(Marker -> OriginX)
  232.                         (*Marker -> Unselect)(Marker,0,OriginY,Marker -> OriginX,1);
  233.                 }
  234.                 else
  235.                 {
  236.                     if(Delta)
  237.                         (*Marker -> Unselect)(Marker,0,OriginY,Marker -> LastX,1);
  238.                     else
  239.                         (*Marker -> Unselect)(Marker,Marker -> LastX,OriginY,Marker -> OriginX - Marker -> LastX,1);
  240.                 }
  241.  
  242.                 Marker -> FirstColumn    = Marker -> OriginX;
  243.                 Marker -> FirstLine     = Marker -> OriginY;
  244.  
  245.                 Marker -> LastX        = Marker -> OriginX;
  246.                 Marker -> LastY        = OriginY;
  247.             }
  248.             else
  249.             {
  250.                 if(OldCharPos < CharOrigin)
  251.                 {
  252.                     if((Lines = Y - Marker -> LastY - 1) >= 0)
  253.                     {
  254.                         (*Marker -> Unselect)(Marker,Marker -> LastX,Marker -> LastY,Marker -> Width - Marker -> LastX,1);
  255.  
  256.                         if(Lines > 0)
  257.                             (*Marker -> Unselect)(Marker,0,Marker -> LastY + 1,Marker -> Width,Lines);
  258.  
  259.                         (*Marker -> Unselect)(Marker,0,Y,X,1);
  260.                     }
  261.                     else
  262.                     {
  263.                         if(Delta)
  264.                             (*Marker -> Unselect)(Marker,0,Y,X,1);
  265.                         else
  266.                             (*Marker -> Unselect)(Marker,Marker -> LastX,Y,X - Marker -> LastX,1);
  267.                     }
  268.  
  269.                     Marker -> FirstColumn    = X;
  270.                     Marker -> FirstLine    = Y + Marker -> Top;
  271.                 }
  272.             }
  273.  
  274.             if(NewCharPos > CharEnd)
  275.             {
  276.                 if((Lines = Y - Marker -> LastY - 1) >= 0)
  277.                 {
  278.                     (*Marker -> Select)(Marker,Marker -> LastX,Marker -> LastY,Marker -> Width - Marker -> LastX,1);
  279.  
  280.                     if(Lines > 0)
  281.                         (*Marker -> Select)(Marker,0,Marker -> LastY + 1,Marker -> Width,Lines);
  282.  
  283.                     (*Marker -> Select)(Marker,0,Y,X,1);
  284.                 }
  285.                 else
  286.                 {
  287.                     if(Delta)
  288.                         (*Marker -> Select)(Marker,0,Y,X,1);
  289.                     else
  290.                         (*Marker -> Select)(Marker,Marker -> LastX,Y,X - Marker -> LastX,1);
  291.                 }
  292.  
  293.                 Marker -> LastColumn    = X;
  294.                 Marker -> LastLine    = Y + Marker -> Top;
  295.             }
  296.         }
  297.         else
  298.         {
  299.             if(Delta && Y > OriginY)
  300.                 (*Marker -> Select)(Marker,0,Y,Marker -> Width,1);
  301.  
  302.             if(Crossed)
  303.             {
  304.                 if((Lines = Marker -> LastY - OriginY - 1) >= 0)
  305.                 {
  306.                     (*Marker -> Unselect)(Marker,0,Marker -> LastY,Marker -> LastX,1);
  307.  
  308.                     if(Lines > 0)
  309.                         (*Marker -> Unselect)(Marker,0,OriginY + 1,Marker -> Width,Lines);
  310.  
  311.                     (*Marker -> Unselect)(Marker,Marker -> OriginX,OriginY,Marker -> Width - Marker -> OriginX,1);
  312.                 }
  313.                 else
  314.                 {
  315.                     if(Delta)
  316.                         (*Marker -> Unselect)(Marker,Marker -> LastX,OriginY,Marker -> Width - Marker -> LastX,1);
  317.                     else
  318.                         (*Marker -> Unselect)(Marker,Marker -> OriginX,OriginY,Marker -> LastX - Marker -> OriginX,1);
  319.                 }
  320.  
  321.                 Marker -> LastColumn    = Marker -> OriginX;
  322.                 Marker -> LastLine    = Marker -> OriginY;
  323.  
  324.                 Marker -> LastX        = Marker -> OriginX;
  325.                 Marker -> LastY        = OriginY;
  326.             }
  327.             else
  328.             {
  329.                 if(OldCharPos > CharOrigin)
  330.                 {
  331.                     if((Lines = Marker -> LastY - Y - 1) >= 0)
  332.                     {
  333.                         if(Marker -> LastX)
  334.                             (*Marker -> Unselect)(Marker,0,Marker -> LastY,Marker -> LastX,1);
  335.  
  336.                         if(Lines > 0)
  337.                             (*Marker -> Unselect)(Marker,0,Y + 1,Marker -> Width,Lines);
  338.  
  339.                         (*Marker -> Unselect)(Marker,X,Y,Marker -> Width - X,1);
  340.                     }
  341.                     else
  342.                     {
  343.                         if(Delta)
  344.                             (*Marker -> Unselect)(Marker,X,Y,Marker -> Width - X,1);
  345.                         else
  346.                             (*Marker -> Unselect)(Marker,X,Y,Marker -> LastX - X,1);
  347.                     }
  348.  
  349.                     Marker -> LastColumn    = X;
  350.                     Marker -> LastLine    = Y + Marker -> Top;
  351.                 }
  352.             }
  353.  
  354.             if(NewCharPos < CharStart)
  355.             {
  356.                 if((Lines = Marker -> LastY - Y - 1) >= 0)
  357.                 {
  358.                     if(Marker -> LastX)
  359.                         (*Marker -> Select)(Marker,0,Marker -> LastY,Marker -> LastX,1);
  360.  
  361.                     if(Lines > 0)
  362.                         (*Marker -> Select)(Marker,0,Y + 1,Marker -> Width,Lines);
  363.  
  364.                     (*Marker -> Select)(Marker,X,Y,Marker -> Width - X,1);
  365.                 }
  366.                 else
  367.                 {
  368.                     if(Delta)
  369.                         (*Marker -> Select)(Marker,X,Y,Marker -> Width - X,1);
  370.                     else
  371.                         (*Marker -> Select)(Marker,X,Y,Marker -> LastX - X,1);
  372.                 }
  373.  
  374.                 Marker -> FirstColumn    = X;
  375.                 Marker -> FirstLine    = Y + Marker -> Top;
  376.             }
  377.         }
  378.  
  379.         Marker -> LastX = X;
  380.         Marker -> LastY = Y;
  381.     }
  382. }
  383.  
  384.  
  385.     /* ToggleSelect(struct BlockMarker *Marker,LONG Left,LONG Top,LONG Width,LONG Height):
  386.      *
  387.      *    Toggle selection subroutine.
  388.      */
  389.  
  390. VOID
  391. ToggleSelect(struct BlockMarker *Marker,LONG Left,LONG Top,LONG Width,LONG Height)
  392. {
  393.     struct RastPort *RPort = (struct RastPort *)Marker -> Object;
  394.  
  395.     if(Width && Height)
  396.     {
  397.         UWORD    OldAPen    = ReadAPen(RPort),
  398.             OldBPen    = ReadBPen(RPort),
  399.             OldDrMd    = ReadDrMd(RPort),
  400.             Mask;
  401.  
  402.         Left    = Marker -> LeftEdge + Left * Marker -> TextFontWidth;
  403.         Top    = Marker -> TopEdge + Top * Marker -> TextFontHeight;
  404.  
  405.         Mask = (1L << RPort -> BitMap -> Depth) - 1;
  406.  
  407.         if(Kick30)
  408.         {
  409.             SetABPenDrMd(RPort,Mask,OldBPen,JAM1 | COMPLEMENT);
  410.  
  411.             RectFill(RPort,Left,Top,Left + Width * Marker -> TextFontWidth - 1,Top + Height * Marker -> TextFontHeight - 1);
  412.  
  413.             SetABPenDrMd(RPort,OldAPen,OldBPen,OldDrMd);
  414.         }
  415.         else
  416.         {
  417.             SetAPen(RPort,Mask);
  418.             SetDrMd(RPort,JAM1 | COMPLEMENT);
  419.  
  420.             RectFill(RPort,Left,Top,Left + Width * Marker -> TextFontWidth - 1,Top + Height * Marker -> TextFontHeight - 1);
  421.  
  422.             SetAPen(RPort,OldAPen);
  423.             SetDrMd(RPort,OldDrMd);
  424.         }
  425.     }
  426. }
  427.  
  428.     /* WriteTrimmedString(struct IFFHandle *Handle,STRPTR String,LONG Len):
  429.      *
  430.      *    Write a string to the clipboard, sans trailing spaces.
  431.      */
  432.  
  433. VOID __regargs
  434. WriteTrimmedString(struct IFFHandle *Handle,STRPTR String,LONG Len)
  435. {
  436.     while(Len > 0 && String[Len - 1] == ' ')
  437.         Len--;
  438.  
  439.     if(Len)
  440.         WriteChunkBytes(Handle,String,Len);
  441. }
  442.  
  443.     /* TrimLength(STRPTR String,LONG Len):
  444.      *
  445.      *    Determine the length of a string, sans trailing spaces.
  446.      */
  447.  
  448. LONG __regargs
  449. TrimLength(STRPTR String,LONG Len)
  450. {
  451.     while(Len > 0)
  452.     {
  453.         if(String[Len - 1] != ' ')
  454.             break;
  455.         else
  456.             Len--;
  457.     }
  458.  
  459.     return(Len);
  460. }
  461.  
  462.     /* ClipPage(struct BlockMarker *Marker,BYTE Append):
  463.      *
  464.      *    Send the entire marked page to the clipboard.
  465.      */
  466.  
  467. STATIC VOID __inline
  468. ClipPage(struct BlockMarker *Marker,BYTE Append)
  469. {
  470.     struct IFFHandle    *Handle;
  471.     APTR             Buffer;
  472.     LONG             Size;
  473.  
  474.     if(Append)
  475.         GetClipContents(Config -> ClipConfig -> ClipboardUnit,&Buffer,&Size);
  476.     else
  477.     {
  478.         Buffer    = NULL;
  479.         Size    = 0;
  480.     }
  481.  
  482.     if(Handle = AllocIFF())
  483.     {
  484.         if(Handle -> iff_Stream = (ULONG)OpenClipboard(Config -> ClipConfig -> ClipboardUnit))
  485.         {
  486.             InitIFFasClip(Handle);
  487.  
  488.             if(!OpenIFF(Handle,IFFF_WRITE))
  489.             {
  490.                 if(!PushChunk(Handle,ID_FTXT,ID_FORM,IFFSIZE_UNKNOWN))
  491.                 {
  492.                     if(!PushChunk(Handle,0,ID_CHRS,IFFSIZE_UNKNOWN))
  493.                     {
  494.                         LONG    Lines = Marker -> LastLine - Marker -> FirstLine - 1,
  495.                             i;
  496.  
  497.                         if(Buffer)
  498.                         {
  499.                             WriteChunkBytes(Handle,Buffer,Size);
  500.  
  501.                             FreeVecPooled(Buffer);
  502.                         }
  503.  
  504.                         WriteTrimmedString(Handle,&Raster[RasterWidth * Marker -> FirstLine + Marker -> FirstColumn],Marker -> Width - Marker -> FirstColumn);
  505.                         WriteChunkBytes(Handle,"\n",1);
  506.  
  507.                         if(Lines > 0)
  508.                         {
  509.                             STRPTR Line = &Raster[(Marker -> FirstLine + 1) * RasterWidth];
  510.  
  511.                             for(i = 0 ; i < Lines ; i++)
  512.                             {
  513.                                 WriteTrimmedString(Handle,Line,Marker -> Width);
  514.                                 WriteChunkBytes(Handle,"\n",1);
  515.  
  516.                                 Line += RasterWidth;
  517.                             }
  518.                         }
  519.  
  520.                         WriteTrimmedString(Handle,&Raster[RasterWidth * Marker -> LastLine],Marker -> LastColumn);
  521.                         WriteChunkBytes(Handle,"\n",1);
  522.  
  523.                         PopChunk(Handle);
  524.                     }
  525.  
  526.                     PopChunk(Handle);
  527.                 }
  528.  
  529.                 CloseIFF(Handle);
  530.             }
  531.  
  532.             CloseClipboard((struct ClipboardHandle *)Handle -> iff_Stream);
  533.         }
  534.  
  535.         FreeIFF(Handle);
  536.     }
  537. }
  538.  
  539.     /* MarkWord(LONG MouseX,LONG MouseY):
  540.      *
  541.      *    Mark a single word on the main screen (double-click).
  542.      */
  543.  
  544. VOID __regargs
  545. MarkWord(LONG MouseX,LONG MouseY)
  546. {
  547.     LONG FirstX,FirstY;
  548.  
  549.     FirstX = MouseX / TextFontWidth;
  550.     FirstY = MouseY / TextFontHeight;
  551.  
  552.     if(FirstX > LastColumn)
  553.         FirstX = LastColumn;
  554.  
  555.     if(FirstY > LastLine)
  556.         FirstY = LastLine;
  557.  
  558.     ObtainSemaphore(RasterSemaphore);
  559.  
  560.     if(Raster[FirstY * RasterWidth + FirstX] != ' ' && Raster[FirstY * RasterWidth + FirstX])
  561.     {
  562.         STRPTR    Line = &Raster[FirstY * RasterWidth];
  563.         LONG    LastX;
  564.  
  565.         LastX = FirstX;
  566.  
  567.         while(FirstX > 0 && Line[FirstX - 1] != ' ')
  568.             FirstX--;
  569.  
  570.         while(LastX < LastColumn && Line[LastX + 1] != ' ')
  571.             LastX++;
  572.  
  573.         ObtainTerminal();
  574.  
  575.         if(WindowMarker = BM_SetMark(Window -> RPort,ToggleSelect,ToggleSelect,LastColumn + 1,LastLine + 1,WindowLeft,WindowTop,0,LastLine + 1,FirstX,FirstY,TextFontWidth,TextFontHeight))
  576.         {
  577.             SetWrMsk(RPort,DepthMask);
  578.  
  579.             Marking = TRUE;
  580.  
  581.             ReportMouse(TRUE,Window);
  582.  
  583.             BM_ExtendMark(WindowMarker,LastX + 1,FirstY,0);
  584.  
  585.             SetClipMenu(TRUE);
  586.         }
  587.  
  588.         ReleaseTerminal();
  589.     }
  590.  
  591.     ReleaseSemaphore(RasterSemaphore);
  592. }
  593.  
  594.     /* SetMarker(LONG MouseX,LONG MouseY):
  595.      *
  596.      *    Anchor a marker to the current mouse position.
  597.      */
  598.  
  599. VOID __regargs
  600. SetMarker(LONG MouseX,LONG MouseY)
  601. {
  602.     LONG FirstX,FirstY;
  603.  
  604.     FirstX = MouseX / TextFontWidth;
  605.     FirstY = MouseY / TextFontHeight;
  606.  
  607.     if(FirstX > LastColumn)
  608.         FirstX = LastColumn;
  609.  
  610.     if(FirstY > LastLine)
  611.         FirstY = LastLine;
  612.  
  613.     ObtainTerminal();
  614.  
  615.     if(WindowMarker = BM_SetMark(Window -> RPort,ToggleSelect,ToggleSelect,LastColumn + 1,LastLine + 1,WindowLeft,WindowTop,0,LastLine + 1,FirstX,FirstY,TextFontWidth,TextFontHeight))
  616.     {
  617.         SetWrMsk(RPort,DepthMask);
  618.  
  619.         Marking = TRUE;
  620.  
  621.         ReportMouse(TRUE,Window);
  622.  
  623.         SetClipMenu(TRUE);
  624.     }
  625.  
  626.     ReleaseTerminal();
  627. }
  628.  
  629.     /* MoveMarker(LONG MouseX,LONG MouseY):
  630.      *
  631.      *    Move the marker with the mouse.
  632.      */
  633.  
  634. VOID __regargs
  635. MoveMarker(LONG MouseX,LONG MouseY)
  636. {
  637.     if(WindowMarker)
  638.     {
  639.         ObtainTerminal();
  640.  
  641.         BM_ExtendMark(WindowMarker,(MouseX + TextFontWidth - 1) / TextFontWidth,MouseY / TextFontHeight,0);
  642.  
  643.         ReleaseTerminal();
  644.     }
  645. }
  646.  
  647.     /* DropMarker():
  648.      *
  649.      *    Drop the window marker, restore the window contents.
  650.      */
  651.  
  652. VOID
  653. DropMarker()
  654. {
  655.     if(WindowMarker)
  656.     {
  657.         struct RastPort    *RPort    = WindowMarker -> Object;
  658.         UBYTE         Mask    = WindowMarker -> WriteMask;
  659.  
  660.         ObtainTerminal();
  661.  
  662.         BM_ClearMark(WindowMarker);
  663.  
  664.         ReleaseTerminal();
  665.  
  666.         SetWrMsk(RPort,Mask);
  667.  
  668.         ReportMouse(FALSE,Window);
  669.  
  670.         WindowMarker = NULL;
  671.  
  672.         Marking = FALSE;
  673.  
  674.         SetClipMenu(FALSE);
  675.     }
  676. }
  677.  
  678.     /* FreeMarker():
  679.      *
  680.      *    Free the main window marker.
  681.      */
  682.  
  683. VOID
  684. FreeMarker()
  685. {
  686.     if(WindowMarker)
  687.     {
  688.         struct RastPort    *RPort    = WindowMarker -> Object;
  689.         UBYTE         Mask    = WindowMarker -> WriteMask;
  690.  
  691.         FreeVecPooled(WindowMarker);
  692.  
  693.         WindowMarker = NULL;
  694.  
  695.         SetWrMsk(RPort,Mask);
  696.  
  697.         ReportMouse(FALSE,Window);
  698.  
  699.         Marking = FALSE;
  700.  
  701.         SetClipMenu(FALSE);
  702.     }
  703. }
  704.  
  705.     /* ClipMarker(BYTE Append):
  706.      *
  707.      *    Transfer the marked area to the clipboard.
  708.      */
  709.  
  710. VOID __regargs
  711. ClipMarker(BYTE Append)
  712. {
  713.     if(WindowMarker)
  714.     {
  715.         ObtainSemaphore(RasterSemaphore);
  716.  
  717.         SetWait(Window);
  718.  
  719.         if(WindowMarker -> FirstColumn == WindowMarker -> Width)
  720.         {
  721.             WindowMarker -> FirstLine++;
  722.  
  723.             WindowMarker -> FirstColumn = 0;
  724.         }
  725.  
  726.         if(WindowMarker -> LastColumn == 0)
  727.         {
  728.             WindowMarker -> LastLine--;
  729.  
  730.             WindowMarker -> LastColumn = WindowMarker -> Width;
  731.         }
  732.  
  733.         if(WindowMarker -> FirstLine <= WindowMarker -> LastLine)
  734.         {
  735.             if(WindowMarker -> FirstLine != WindowMarker -> LastLine || WindowMarker -> FirstColumn != WindowMarker -> LastColumn)
  736.             {
  737.                 if(WindowMarker -> FirstLine == WindowMarker -> LastLine)
  738.                 {
  739.                     if(Append)
  740.                         AddClip(&Raster[RasterWidth * WindowMarker -> FirstLine + WindowMarker -> FirstColumn],WindowMarker -> LastColumn - WindowMarker -> FirstColumn);
  741.                     else
  742.                         SaveClip(&Raster[RasterWidth * WindowMarker -> FirstLine + WindowMarker -> FirstColumn],WindowMarker -> LastColumn - WindowMarker -> FirstColumn);
  743.                 }
  744.                 else
  745.                     ClipPage(WindowMarker,Append);
  746.             }
  747.         }
  748.  
  749.         ClrWait(Window);
  750.  
  751.         ReleaseSemaphore(RasterSemaphore);
  752.  
  753.         DropMarker();
  754.     }
  755. }
  756.